package com.solo.system.service.impl;

import com.solo.common.core.base.service.impl.BasicServiceImpl;
import com.solo.system.api.entity.SysI18nType;
import com.solo.system.mapper.SysI18nTypeMapper;
import com.solo.system.model.i18n.type.SysI18nTypeConvert;
import com.solo.system.model.i18n.type.req.I18nTypeCreateReq;
import com.solo.system.model.i18n.type.req.I18nTypeUpdateReq;
import com.solo.system.model.i18n.type.req.I18nTypeUpdateStatusReq;
import com.solo.system.service.SysI18nTypeService;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

import static com.solo.common.core.utils.ServiceExceptionUtil.exception;
import static com.solo.system.api.consts.SystemCode.*;

/**
 * 国际化语言类型 Service实现类
 * @author 十一
 * @since 2024-10-23 15:10
 * 人生若只如初见，何事秋风悲画扇
 **/
@Service
@AllArgsConstructor
public class SysI18nTypeServiceImpl extends BasicServiceImpl<SysI18nTypeMapper, SysI18nType> implements SysI18nTypeService {

    @Override
    @Transactional
    public boolean create(I18nTypeCreateReq req) {
        // 验证语言包是否可以设置成默认
        validateSettingDefault(req.getIsDefault(), req.getStatus());
        // 如果新增的语言是默认的，则先将全部语言设置成[否]
        if (req.getIsDefault()) {
            mapper.updateIsDefault(null);
        }
        // 保存国际化语言类型
        return save(SysI18nTypeConvert.INSTANCE.convert(req));
    }

    // 
    @Override
    @Transactional
    public boolean delete(List<Long> typeIds) {
        List<SysI18nType> i18nTypes = mapper.selectListByIds(typeIds);
        i18nTypes.forEach(i18nType -> validateDefault(i18nType.getTypeId(), false));
        // 批量删除国际化语言类型
        return removeByIds(typeIds);
    }

    @Override
    @Transactional
    public boolean update(I18nTypeUpdateReq req) {
        // 验证语言包是否存在
        SysI18nType oldRecord = validateExists(req.getTypeId());
        // 验证语言包是否必须有一个默认值
        validateDefault(req.getTypeId(), req.getIsDefault());
        // 验证语言包是否可以设置成默认
        validateSettingDefault(req.getIsDefault(), req.getStatus());
        // 如果新记录是默认的 && 旧记录不是默认的，可以修改
        if (req.getIsDefault() && !oldRecord.getIsDefault()) {
            mapper.updateIsDefault(req.getTypeId());
        }
        // 更新国际化语言类型
        return updateById(SysI18nTypeConvert.INSTANCE.convert(req));
    }

    @Override
    @Transactional
    public boolean updateStatus(I18nTypeUpdateStatusReq req) {
        SysI18nType entity = SysI18nTypeConvert.INSTANCE.convert(req);
        // 验证语言包是否存在
        validateExists(entity.getTypeId());
        // 验证语言包是否必须默认
        validateDefault(entity.getTypeId(), false);
        // 更新国际化语言类型
        return updateById(entity);
    }

    /**
     * 验证语言包是否存在
     * @param typeId 类型id
     */
    SysI18nType validateExists(Long typeId) {
        if (typeId == null) {
            throw exception(I18N_TYPE_NOT_FOUND);
        }
        SysI18nType i18nType = mapper.selectOneById(typeId);
        if (i18nType == null) {
            throw exception(I18N_TYPE_NOT_FOUND);
        }
        return i18nType;
    }

    /**
     * 验证语言包是否必须有一个默认值
     * @param typeId 类型id
     * @param isDefault 新纪录是否默认
     */
    void validateDefault(Long typeId, boolean isDefault) {
        if (typeId == null) {
            throw exception(I18N_TYPE_MUST_DEFAULT);
        }
        SysI18nType i18nType = mapper.selectOneById(typeId);
        if (i18nType == null) {
            throw exception(I18N_TYPE_MUST_DEFAULT);
        }
        // 如果新记录不是默认的 && 旧记录是默认的 必须得有一个默认语言
        if (!isDefault && i18nType.getIsDefault()) {
            throw exception(I18N_TYPE_MUST_DEFAULT);
        }
    }

    /**
     * 验证记录是否可以设置成默认
     * @param isDefault 是默认值
     * @param status 状态
     */
    void validateSettingDefault(boolean isDefault, boolean status) {
        // 如果记录是默认的 && 状态是禁用 无法将禁用状态的数据设置成默认
        if (isDefault && !status) {
            throw exception(I18N_TYPE_CANT_SETTING_DEFAULT);
        }
    }

}
